package com.styletransfer.controller;

import com.styletransfer.model.ApiResponse;
import com.styletransfer.model.PageRequest;
import com.styletransfer.model.PageResponse;
import com.styletransfer.model.Style;
import com.styletransfer.model.StyleCategory;
import com.styletransfer.model.Work;
import com.styletransfer.service.StyleService;
import com.styletransfer.service.WorkService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 风格控制器
 *
 * 提供风格相关的API接口，包括创建、更新、删除、查询风格等
 */
@RestController
@RequestMapping("/style")
public class StyleController {

    @Autowired
    private StyleService styleService;
    @Autowired
    private WorkService workService;

    /**
     * 创建风格
     *
     * @param requestMap 包含风格信息和标签的请求数据
     * @return API响应
     */
    @PostMapping("/create")
    public ApiResponse<Style> createStyle(
            @RequestBody Map<String, Object> requestMap) {

        // 从请求数据中提取风格信息
        Style style = new Style();
        
        // 设置基本属性
        if (requestMap.containsKey("name")) {
            style.setName((String) requestMap.get("name"));
        }
        if (requestMap.containsKey("description")) {
            style.setDescription((String) requestMap.get("description"));
        }
        if (requestMap.containsKey("status")) {
            style.setStatus(Integer.valueOf(requestMap.get("status").toString()));
        }
        if (requestMap.containsKey("category")) {
            style.setCategory(Long.valueOf(requestMap.get("category").toString()));
        }
        if (requestMap.containsKey("coverImage")) {
            style.setCoverImage((String) requestMap.get("coverImage"));
        }
        if (requestMap.containsKey("previewImage")) {
            style.setPreviewImage((String) requestMap.get("previewImage"));
        }
        
        // 从请求数据中提取tags
        List<Long> tagIds = null;
        if (requestMap.containsKey("tags") && requestMap.get("tags") != null) {
            String tags = requestMap.get("tags").toString();
            if (!tags.isEmpty()) {
                tagIds = Arrays.stream(tags.split(","))
                        .map(String::trim)
                        .filter(s -> !s.isEmpty())
                        .map(Long::parseLong)
                        .collect(Collectors.toList());
            }
        }

        return styleService.createStyle(style, tagIds);
    }

    /**
     * 更新风格
     *
     * @param id 风格ID
     * @param requestMap 包含风格信息和标签的请求数据
     * @return API响应
     */
    @PostMapping("/update/{id}")
    public ApiResponse<Style> updateStyle(
            @PathVariable Long id,
            @RequestBody Map<String, Object> requestMap) {

        // 从请求数据中提取风格信息
        Style style = new Style();
        style.setId(id);

        // 设置基本属性
        if (requestMap.containsKey("name")) {
            style.setName((String) requestMap.get("name"));
        }
        if (requestMap.containsKey("description")) {
            style.setDescription((String) requestMap.get("description"));
        }
        if (requestMap.containsKey("status")) {
            style.setStatus(Integer.valueOf(requestMap.get("status").toString()));
        }
        if (requestMap.containsKey("category")) {
            style.setCategory(Long.valueOf(requestMap.get("category").toString()));
        }
        if (requestMap.containsKey("coverImage")) {
            style.setCoverImage((String) requestMap.get("coverImage"));
        }
        if (requestMap.containsKey("previewImage")) {
            style.setPreviewImage((String) requestMap.get("previewImage"));
        }

        // 从请求数据中提取tags
        List<Long> tagIds = null;
        if (requestMap.containsKey("tags") && requestMap.get("tags") != null) {
            String tags = requestMap.get("tags").toString();
            if (!tags.isEmpty()) {
                tagIds = Arrays.stream(tags.split(","))
                        .map(String::trim)
                        .filter(s -> !s.isEmpty())
                        .map(Long::parseLong)
                        .collect(Collectors.toList());
            }
        }

        return styleService.updateStyle(style, tagIds);
    }

    /**
     * 删除风格
     *
     * @param id 风格ID
     * @return API响应
     */
    @PostMapping("/delete/{id}")
    public ApiResponse<Void> deleteStyle(@PathVariable Long id) {
        return styleService.deleteStyle(id);
    }

    /**
     * 根据ID获取风格
     *
     * @param id 风格ID
     * @return API响应
     */
    @GetMapping("/{id}")
    public ApiResponse<Style> getStyleById(@PathVariable Long id) {
        return styleService.findById(id);
    }

    /**
     * 获取所有风格
     *
     * @return API响应
     */
    @GetMapping("/all")
    public ApiResponse<List<Style>> getAllStyles() {
        return styleService.findAll();
    }

    /**
     * 获取公开的风格
     *
     * @return API响应
     */
    @GetMapping("/public")
    public ApiResponse<List<Style>> getPublicStyles() {
        return styleService.findPublic();
    }

    /**
     * 获取热门风格
     *
     * @param limit 限制数量
     * @return API响应
     */
    @GetMapping("/hot")
    public ApiResponse<List<Style>> getHotStyles(@RequestParam(defaultValue = "10") Integer limit) {
        return styleService.findHot(limit);
    }

    /**
     * 获取最新风格
     *
     * @param limit 限制数量
     * @return API响应
     */
    @GetMapping("/latest")
    public ApiResponse<List<Style>> getLatestStyles(@RequestParam(defaultValue = "10") Integer limit) {
        return styleService.findLatest(limit);
    }

    /**
     * 获取用户的风格
     *
     * @param userId 用户ID
     * @return API响应
     */
    @GetMapping("/user/{userId}")
    public ApiResponse<List<Style>> getUserStyles(@PathVariable Long userId) {
        return styleService.findByUser(userId);
    }

    /**
     * 获取当前用户的风格
     *
     * @return API响应
     */
    @GetMapping("/my")
    public ApiResponse<List<Style>> getMyStyles() {
        return styleService.findByCurrentUser();
    }

    /**
     * 搜索风格
     *
     * @param keyword 关键词
     * @return API响应
     */
    @GetMapping("/search")
    public ApiResponse<List<Style>> searchStyles(@RequestParam String keyword) {
        return styleService.search(keyword);
    }

    /**
     * 根据标签获取风格
     *
     * @param tagId 标签ID
     * @return API响应
     */
    @GetMapping("/tag/{tagId}")
    public ApiResponse<List<Style>> getStylesByTag(@PathVariable Long tagId) {
        return styleService.findByTag(tagId);
    }

    /**
     * 分页查询风格
     *
     * @param page 页码
     * @param size 每页数量
     * @param keyword 关键词
     * @param tagId 标签ID
     * @param categoryId 分类ID
     * @param userId 用户ID
     * @param orderBy 排序字段
     * @param orderType 排序类型
     * @return API响应
     */
    @GetMapping("/page")
    public ApiResponse<PageResponse<Style>> getStylesByPage(
            @RequestParam(defaultValue = "1") Integer page,
            @RequestParam(defaultValue = "10") Integer size,
            @RequestParam(required = false) String keyword,
            @RequestParam(required = false) Long tagId,
            @RequestParam(required = false) Long categoryId,
            @RequestParam(required = false) Long userId,
            @RequestParam(defaultValue = "id") String orderBy,
            @RequestParam(defaultValue = "desc") String orderType) {
        PageRequest pageRequest = new PageRequest(page, size);
        PageResponse<Style> pageResponse = styleService.findByPage(pageRequest, keyword, tagId, categoryId, userId, orderBy, orderType);
        return ApiResponse.success(pageResponse);
    }

    /**
     * 增加风格使用次数
     *
     * @param id 风格ID
     * @return API响应
     */
    @PostMapping("/increment-use/{id}")
    public ApiResponse<Void> incrementUseCount(@PathVariable Long id) {
        return styleService.incrementUseCount(id);
    }

    /**
     * 获取相关风格
     *
     * @param id 风格ID
     * @param limit 限制数量
     * @return API响应
     */
    @GetMapping("/related/{id}")
    public ApiResponse<List<Style>> getRelatedStyles(
            @PathVariable Long id,
            @RequestParam(defaultValue = "5") Integer limit) {
        return styleService.findRelatedStyles(id, limit);
    }

    /**
     * 获取风格相关作品
     *
     * @param id 风格ID
     * @param page 页码
     * @param size 每页数量
     * @return API响应
     */
    @GetMapping("/{id}/works")
    public ApiResponse<PageResponse<Work>> getStyleWorks(
            @PathVariable Long id,
            @RequestParam(defaultValue = "1") Integer page,
            @RequestParam(defaultValue = "10") Integer size) {
        PageRequest pageRequest = new PageRequest(page, size);
        return styleService.findStyleWorks(id, pageRequest);
    }

    /**
     * 收藏/取消收藏风格
     *
     * @param id 风格ID
     * @param requestBody 请求体
     * @return API响应
     */
    @PostMapping("/{id}/favorite")
    public ApiResponse<Void> toggleFavorite(
            @PathVariable Long id,
            @RequestBody Map<String, Boolean> requestBody) {
        Boolean favorite = requestBody.get("favorite");
        return styleService.toggleFavorite(id, favorite);
    }

    /**
     * 检查风格是否已收藏
     *
     * @param id 风格ID
     * @return API响应
     */
    @GetMapping("/{id}/is-favorite")
    public ApiResponse<Boolean> checkFavorite(@PathVariable Long id) {
        return styleService.isFavorite(id);
    }

    /**
     * 获取风格分类列表
     *
     * @return API响应
     */
    @GetMapping("/categories")
    public ApiResponse<List<StyleCategory>> getStyleCategories() {
        return styleService.getStyleCategories();
    }

    /**
     * 根据ID数组批量获取风格列表
     *
     * @param requestMap 包含风格ID数组的请求数据
     * @return API响应
     */
    @PostMapping("/batch")
    public ApiResponse<List<Style>> getStylesByIds(@RequestBody Map<String, Object> requestMap) {
        List<Long> ids = null;
        if (requestMap.containsKey("ids") && requestMap.get("ids") != null) {
            ids = (List<Long>) requestMap.get("ids");
        }
        
        if (ids == null || ids.isEmpty()) {
            return ApiResponse.error("风格ID列表不能为空");
        }
        
        return styleService.findByIds(ids);
    }

    /**
     * 获取所有风格分类（包括禁用的）
     *
     * @return API响应
     */
    @GetMapping("/categories/all")
    public ApiResponse<List<StyleCategory>> getAllStyleCategories() {
        return styleService.getAllStyleCategories();
    }

    /**
     * 根据ID获取风格分类
     *
     * @param id 分类ID
     * @return API响应
     */
    @GetMapping("/category/{id}")
    public ApiResponse<StyleCategory> getStyleCategoryById(@PathVariable Long id) {
        return styleService.getStyleCategoryById(id);
    }

    /**
     * 创建风格分类
     *
     * @param category 风格分类
     * @return API响应
     */
    @PostMapping("/category/create")
    public ApiResponse<StyleCategory> createStyleCategory(@RequestBody StyleCategory category) {
        return styleService.createStyleCategory(category);
    }

    /**
     * 更新风格分类
     *
     * @param id 分类ID
     * @param category 风格分类
     * @return API响应
     */
    @PostMapping("/category/update/{id}")
    public ApiResponse<StyleCategory> updateStyleCategory(
            @PathVariable Long id,
            @RequestBody StyleCategory category) {
        category.setId(id);
        return styleService.updateStyleCategory(category);
    }

    /**
     * 删除风格分类
     *
     * @param id 分类ID
     * @return API响应
     */
    @PostMapping("/category/delete/{id}")
    public ApiResponse<Void> deleteStyleCategory(@PathVariable Long id) {
        return styleService.deleteStyleCategory(id);
    }

    /**
     * 更新风格分类状态
     *
     * @param id 分类ID
     * @param status 状态
     * @return API响应
     */
    @PostMapping("/category/{id}/status")
    public ApiResponse<Void> updateStyleCategoryStatus(
            @PathVariable Long id,
            @RequestParam Integer status) {
        return styleService.updateStyleCategoryStatus(id, status);
    }
}
